#include <algorithm>

template <typename Object>//模板化
class Vector{
 public://公用接口,用于实现Vector类的相应功能
  explicit Vector( int initSize = 0 ) : theSize{ initSize },
         theCapacity{ initSize + SPARE_CAPACITY }
      { objects = new Object[ theCapacity]; }
      
     Vector( const Vector & rhs ) : theSize{ rhs.theSize }, 
	theCapacity{ rhs.theCapacity }, objects{ nullptr }//复制构造函数
     {
	 objects = new Object [ theCapacity ];
	 for( int k = 0; k < theSize; ++k)
	   objects[ k ] = rhs.objects[ k ]; 
		       

     }	    

     Vector & operator= ( const Vector & rhs)//重载运算operator=，进行类似数组的访问
     {
         Vector copy = rhs;
	 std::swap( *this, copy);
	 return *this;
     }

     ~Vector()//析构函数，删除Vecrtor的指针，用于程序结束后释放内存
       { delete [] objects; }
     

     Vector( Vector && rhs ) : theSize{ rhs.theSize },
       theCapacity{ rhs.theCapacity }, objects{ rhs.objects }//右值复制函数
     {
	 rhs.objects = nullptr;
	 rhs.theSize = 0;
	 rhs.theCapacity = 0;
     }

     Vector & operator= ( Vector && rhs) //右值引用实现重载运算operator=
     {
	 std::swap( theSize, rhs.theSize);
	 std::swap( theCapacity, rhs.theCapacity);
	 std::swap( objects, rhs.objects);

	 return *this;
     }


     void resize( int newSize )//当Size>Capcity时，调整Capcity的大小为原来两倍
     {
	 if( newSize > theCapacity )
	     reserve( newSize * 2 );
	 theSize = newSize;
     }

     void reserve( int newCapacity )//扩容Capcity
     {
         if( newCapacity < theSize )
	     return;

         Object *newArray = new Object[ newCapacity ];
	 for( int k = 0; k < theSize; ++k)
	     newArray[ k ] = std::move( objects[ k ] );

	 theCapacity = newCapacity;
	 std::swap( objects, newArray );
	 delete [] newArray;
     }
     
	 Object & operator[]( int index )
	   { return objects[ index ]; }
	 const Object & operator[] ( int index ) const
	   { return objects[ index ]; }
	 
	 bool empty() const//判断空
	   { return size() == 0; }
	 int size() const
	   { return theSize; }
	 int capacity() const
	   { return theCapacity; }
	 
	 void push_back(const Object & x)//在最后增加一个元素
	 {
	     if( theSize == theCapacity )
		 reserve( 2 * theCapacity + 1 );
	     objects[ theSize++ ] = x;
	 }

	 void push_back(Object && x )//右值引用实现push_back
	 {
	     if( theSize == theCapacity )
		 reserve( 2 * theCapacity + 1 );
	     objects[ theSize++ ] = std::move( x );
	 }

	 void pop_back()//删除最后一个元素
	 {
	     --theSize;
	 }

	 const Object & back () const
	 {
	      return objects[ theSize - 1 ];
	 }
	 
	 typedef Object * iterator;
	 typedef const Object * const_iterator;

     	 iterator begin()//迭代器
	   { return &objects[ 0 ]; }
	 const_iterator begin() const
	   { return &objects[ 0 ]; }

	 iterator end()
	   { return &objects[ size() ]; }
	 const_iterator end() const
	   { return &objects[ size() ]; }

	 static const int SPARE_CAPACITY = 16;//声明Capcity默认大小

  private:
    int theSize;
    int theCapacity;
    Object * objects;		
};
